home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 335_03 / as8048.y < prev    next >
Encoding:
Lex Description  |  1990-12-02  |  39.4 KB  |  1,757 lines
  1. %{
  2.  
  3. /*
  4. HEADER:     ;
  5. TITLE:         Frankenstein Cross Assemblers;
  6. VERSION:     2.0;
  7. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  8.         Hex format object records.  ";
  9. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  10.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  11. SYSTEM:     UNIX, MS-Dos ;
  12. FILENAME:     as8048.y;
  13. WARNINGS:     "This software is in the public domain.  
  14.         Any prior copyright claims are relinquished.  
  15.  
  16.         This software is distributed with no warranty whatever.  
  17.         The author takes no responsibility for the consequences 
  18.         of its use.
  19.  
  20.         Yacc (or Bison) required to compile."  ;
  21. SEE-ALSO:     as8048.doc,frasmain.c;    
  22. AUTHORS:     Mark Zenier;
  23. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  24.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  25. */
  26. /* 8048  et al  instruction generation file */
  27. /* November 17, 1990 */
  28.  
  29. /*
  30.     description    frame work parser description for framework cross
  31.             assemblers
  32.     history        February 2, 1988
  33.             September 11, 1990 - merge table definition
  34.             September 12, 1990 - short file names
  35.             September 14, 1990 - short variable names
  36.             September 17, 1990 - use yylex as external
  37. */
  38. #include <stdio.h>
  39. #include "frasmdat.h"
  40. #include "fragcon.h"
  41.  
  42. #define yylex lexintercept
  43.  
  44. /* 0000.0000.0000.xxxx  interrupt selections */
  45. #define    ISELMASK    0xf
  46. #define    ISELI        0x1
  47. #define    ISELTCNTI    0x2
  48. #define    ISELDMA        0x4
  49. #define    ISELFLAGS    0x8
  50. /* 0000.0000.0000.xxxx  accum-flag selections */
  51. #define    AFSELMASK    0xf
  52. #define    AFSELA        0x1
  53. #define    AFSELC        0x2
  54. #define    AFSELF0        0x4
  55. #define    AFSELF1        0x8
  56. /* 0000.0000.xxxx.0000  low port selections */
  57. #define    PSELMASK    0xf0
  58. #define    PSELBUS        0x10
  59. #define    PSELP1        0x20
  60. #define    PSELP2        0x40
  61. #define    PSELDBB        0x80
  62. /* 0000.00xx.xxxx.0000  misc register selections */
  63. #define    MSELMASK    0x3f0
  64. #define    MSELPSW        0x10
  65. #define    MSELT        0x20
  66. #define    MSELCNT        0x40
  67. #define    MSELTCNT    0x80
  68. #define    MSELCLK        0x100
  69. #define    MSELSTS        0x200
  70. /* 0000.xx00.0000.0000  ram size */
  71. #define    RAMSIZEMASK    0xc00
  72. #define    RAMSIZE64    0x400
  73. #define    RAMSIZE128    0x800
  74. #define    RAMSIZE256    0xc00
  75. /* xxx0.0000.0000.0000  instruction set variations */
  76. #define    INSTIDL        0x8000
  77. #define    INSTNOT41    0x4000
  78. #define    INST41        0x2000
  79. #define    CPU8048        INSTNOT41|RAMSIZE64
  80. #define    CPU8049        INSTNOT41|RAMSIZE128
  81. #define    CPU8050        INSTNOT41|RAMSIZE256
  82. #define    CPU80C48    INSTNOT41|INSTIDL|RAMSIZE64
  83. #define    CPU80C49    INSTNOT41|INSTIDL|RAMSIZE128
  84. #define    CPU80C50    INSTNOT41|INSTIDL|RAMSIZE256
  85. #define    CPU8041        INST41|RAMSIZE64
  86. #define    CPU8042        INST41|RAMSIZE128
  87. #define ST_AF 0x1
  88. #define ST_REG 0x2
  89. #define ST_EXPR 0x4
  90. #define ST_AR 0x8
  91. #define ST_AINDIRR 0x10
  92. #define ST_AIMMED 0x20
  93. #define ST_INDIRA 0x40
  94. #define ST_INDIRR 0x80
  95. #define ST_REGEXP 0x100
  96. #define ST_PA2 0x200
  97. #define ST_PA4 0x400
  98. #define ST_P2A 0x800
  99. #define ST_P4A 0x1000
  100. #define ST_P2IMMED 0x2000
  101. #define ST_INH 0x1
  102. #define ST_INT 0x2
  103. #define ST_RSELC 0x4
  104. #define ST_MSELC 0x8
  105. #define ST_MREG 0x10
  106. #define ST_MAR 0x1
  107. #define ST_MAINDIRA 0x2
  108. #define ST_MAINDIRR 0x4
  109. #define ST_MAIMMED 0x8
  110. #define ST_MAMR 0x10
  111. #define ST_MMRA 0x20
  112. #define ST_MRA 0x40
  113. #define ST_MRIMMED 0x80
  114. #define ST_MINDIRRA 0x100
  115. #define ST_MINDIRRIM 0x200
  116.     
  117.     static char    genbdef[] = "[1=];";
  118.     static char    genwdef[] = "[1=]y"; /* x for normal, y for byte rev */
  119.     char ignosyn[] = "[Xinvalid syntax for instruction";
  120.     char ignosel[] = "[Xinvalid operands/illegal instruction for cpu";
  121.     int    cpuselect = CPU80C50;
  122.  
  123.     long    labelloc;
  124.     static int satsub;
  125.     int    ifstkpt = 0;
  126.     int    fraifskip = FALSE;
  127.  
  128.     struct symel * endsymbol = SYMNULL;
  129.  
  130. %}
  131. %union {
  132.     int    intv;
  133.     long     longv;
  134.     char    *strng;
  135.     struct symel *symb;
  136. }
  137.  
  138. %token <intv> RSELC
  139. %token <intv> MSELC
  140. %token <intv> INT
  141. %token <intv> AF
  142. %token <intv> REG
  143. %token <intv> P02
  144. %token <intv> P47
  145. %token <intv> MREG
  146. %token <intv> KOC_BDEF
  147. %token <intv> KOC_ELSE
  148. %token <intv> KOC_END
  149. %token <intv> KOC_ENDI
  150. %token <intv> KOC_EQU
  151. %token <intv> KOC_IF
  152. %token <intv> KOC_INCLUDE
  153. %token <intv> KOC_ORG
  154. %token <intv> KOC_RESM
  155. %token <intv> KOC_SDEF
  156. %token <intv> KOC_SET
  157. %token <intv> KOC_WDEF
  158. %token <intv> KOC_CHSET
  159. %token <intv> KOC_CHDEF
  160. %token <intv> KOC_CHUSE
  161. %token <intv> KOC_CPU
  162. %token <intv> KOC_REG
  163. %token <intv> KOC_opcode
  164. %token <intv> KOC_misc
  165. %token <intv> KOC_mov
  166.  
  167. %token <longv> CONSTANT
  168. %token EOL
  169. %token KEOP_AND
  170. %token KEOP_DEFINED
  171. %token KEOP_EQ
  172. %token KEOP_GE
  173. %token KEOP_GT
  174. %token KEOP_HIGH
  175. %token KEOP_LE
  176. %token KEOP_LOW
  177. %token KEOP_LT
  178. %token KEOP_MOD
  179. %token KEOP_MUN
  180. %token KEOP_NE
  181. %token KEOP_NOT
  182. %token KEOP_OR
  183. %token KEOP_SHL
  184. %token KEOP_SHR
  185. %token KEOP_XOR
  186. %token KEOP_locctr
  187. %token <symb> LABEL
  188. %token <strng> STRING
  189. %token <symb> SYMBOL
  190.  
  191. %token KTK_invalid
  192.  
  193. %right    KEOP_HIGH KEOP_LOW
  194. %left    KEOP_OR KEOP_XOR
  195. %left    KEOP_AND
  196. %right    KEOP_NOT
  197. %nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
  198. %left    '+' '-'
  199. %left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
  200. %right    KEOP_MUN
  201.  
  202.  
  203. %type <intv> expr exprlist stringlist
  204.  
  205. %start file
  206.  
  207. %%
  208.  
  209. file    :    file allline
  210.     |    allline
  211.     ;
  212.  
  213. allline    :     line EOL
  214.             {
  215.                 clrexpr();
  216.             }
  217.     |    EOL
  218.     |    error EOL
  219.             {
  220.                 clrexpr();
  221.                 yyerrok;
  222.             }
  223.     ;
  224.  
  225. line    :    LABEL KOC_END 
  226.             {
  227.                 endsymbol = $1;
  228.                 nextreadact = Nra_end;
  229.             }
  230.     |          KOC_END 
  231.             {
  232.                 nextreadact = Nra_end;
  233.             }
  234.     |    KOC_INCLUDE STRING
  235.             {
  236.         if(nextfstk >= FILESTKDPTH)
  237.         {
  238.             fraerror("include file nesting limit exceeded");
  239.         }
  240.         else
  241.         {
  242.             infilestk[nextfstk].fnm = savestring($2,strlen($2));
  243.             if( (infilestk[nextfstk].fpt = fopen($2,"r"))
  244.                 ==(FILE *)NULL )
  245.             {
  246.                 fraerror("cannot open include file");
  247.             }
  248.             else
  249.             {
  250.                 nextreadact = Nra_new;
  251.             }
  252.         }
  253.             }
  254.     |    LABEL KOC_EQU expr 
  255.             {
  256.                 if($1 -> seg == SSG_UNDEF)
  257.                 {
  258.                     pevalexpr(0, $3);
  259.                     if(evalr[0].seg == SSG_ABS)
  260.                     {
  261.                         $1 -> seg = SSG_EQU;
  262.                         $1 -> value = evalr[0].value;
  263.                         prtequvalue("C: 0x%lx\n",
  264.                             evalr[0].value);
  265.                     }
  266.                     else
  267.                     {
  268.                         fraerror(
  269.                     "noncomputable expression for EQU");
  270.                     }
  271.                 }
  272.                 else
  273.                 {
  274.                     fraerror(
  275.                 "cannot change symbol value with EQU");
  276.                 }
  277.             }
  278.     |    LABEL KOC_SET expr 
  279.             {
  280.                 if($1 -> seg == SSG_UNDEF
  281.                    || $1 -> seg == SSG_SET)
  282.                 {
  283.                     pevalexpr(0, $3);
  284.                     if(evalr[0].seg == SSG_ABS)
  285.                     {
  286.                         $1 -> seg = SSG_SET;
  287.                         $1 -> value = evalr[0].value;
  288.                         prtequvalue("C: 0x%lx\n",
  289.                             evalr[0].value);
  290.                     }
  291.                     else
  292.                     {
  293.                         fraerror(
  294.                     "noncomputable expression for SET");
  295.                     }
  296.                 }
  297.                 else
  298.                 {
  299.                     fraerror(
  300.                 "cannot change symbol value with SET");
  301.                 }
  302.             }
  303.     |    KOC_IF expr 
  304.             {
  305.         if((++ifstkpt) < IFSTKDEPTH)
  306.         {
  307.             pevalexpr(0, $2);
  308.             if(evalr[0].seg == SSG_ABS)
  309.             {
  310.                 if(evalr[0].value != 0)
  311.                 {
  312.                     elseifstk[ifstkpt] = If_Skip;
  313.                     endifstk[ifstkpt] = If_Active;
  314.                 }
  315.                 else
  316.                 {
  317.                     fraifskip = TRUE;
  318.                     elseifstk[ifstkpt] = If_Active;
  319.                     endifstk[ifstkpt] = If_Active;
  320.                 }
  321.             }
  322.             else
  323.             {
  324.                 fraifskip = TRUE;
  325.                 elseifstk[ifstkpt] = If_Active;
  326.                 endifstk[ifstkpt] = If_Active;
  327.             }
  328.         }
  329.         else
  330.         {
  331.             fraerror("IF stack overflow");
  332.         }
  333.             }
  334.                         
  335.     |    KOC_IF 
  336.             {
  337.         if(fraifskip) 
  338.         {
  339.             if((++ifstkpt) < IFSTKDEPTH)
  340.             {
  341.                     elseifstk[ifstkpt] = If_Skip;
  342.                     endifstk[ifstkpt] = If_Skip;
  343.             }
  344.             else
  345.             {
  346.                 fraerror("IF stack overflow");
  347.             }
  348.         }
  349.         else
  350.         {
  351.             yyerror("syntax error");
  352.             YYERROR;
  353.         }
  354.                 }
  355.                         
  356.     |    KOC_ELSE 
  357.             {
  358.                 switch(elseifstk[ifstkpt])
  359.                 {
  360.                 case If_Active:
  361.                     fraifskip = FALSE;
  362.                     break;
  363.                 
  364.                 case If_Skip:
  365.                     fraifskip = TRUE;
  366.                     break;
  367.                 
  368.                 case If_Err:
  369.                     fraerror("ELSE with no matching if");
  370.                     break;
  371.                 }
  372.             }
  373.  
  374.     |    KOC_ENDI 
  375.             {
  376.                 switch(endifstk[ifstkpt])
  377.                 {
  378.                 case If_Active:
  379.                     fraifskip = FALSE;
  380.                     ifstkpt--;
  381.                     break;
  382.                 
  383.                 case If_Skip:
  384.                     fraifskip = TRUE;
  385.                     ifstkpt--;
  386.                     break;
  387.                 
  388.                 case If_Err:
  389.                     fraerror("ENDI with no matching if");
  390.                     break;
  391.                 }
  392.             }
  393.     |    LABEL KOC_ORG expr 
  394.             {
  395.                 pevalexpr(0, $3);
  396.                 if(evalr[0].seg == SSG_ABS)
  397.                 {
  398.                     locctr = labelloc = evalr[0].value;
  399.                     if($1 -> seg == SSG_UNDEF)
  400.                     {
  401.                         $1 -> seg = SSG_ABS;
  402.                         $1 -> value = labelloc;
  403.                     }
  404.                     else
  405.                         fraerror(
  406.                         "multiple definition of label");
  407.                     prtequvalue("C: 0x%lx\n",
  408.                         evalr[0].value);
  409.                 }
  410.                 else
  411.                 {
  412.                     fraerror(
  413.                      "noncomputable expression for ORG");
  414.                 }
  415.             }
  416.     |          KOC_ORG expr 
  417.             {
  418.                 pevalexpr(0, $2);
  419.                 if(evalr[0].seg == SSG_ABS)
  420.                 {
  421.                     locctr = labelloc = evalr[0].value;
  422.                     prtequvalue("C: 0x%lx\n",
  423.                         evalr[0].value);
  424.                 }
  425.                 else
  426.                 {
  427.                     fraerror(
  428.                      "noncomputable expression for ORG");
  429.                 }
  430.             }
  431.     |    LABEL KOC_CHSET
  432.             {
  433.                 if($1 -> seg == SSG_UNDEF)
  434.                 {
  435.                     $1 -> seg = SSG_EQU;
  436.                     if( ($1->value = chtcreate()) <= 0)
  437.                     {
  438.         fraerror( "cannot create character translation table");
  439.                     }
  440.                     prtequvalue("C: 0x%lx\n", $1 -> value);
  441.                 }
  442.                 else
  443.                 {
  444.             fraerror( "multiple definition of label");
  445.                 }
  446.             }
  447.     |        KOC_CHUSE
  448.             {
  449.                 chtcpoint = (int *) NULL;
  450.                 prtequvalue("C: 0x%lx\n", 0L);
  451.             }
  452.     |        KOC_CHUSE expr
  453.             {
  454.                 pevalexpr(0, $2);
  455.                 if( evalr[0].seg == SSG_ABS)
  456.                 {
  457.                     if( evalr[0].value == 0)
  458.                     {
  459.                         chtcpoint = (int *)NULL;
  460.                         prtequvalue("C: 0x%lx\n", 0L);
  461.                     }
  462.                     else if(evalr[0].value < chtnxalph)
  463.                     {
  464.                 chtcpoint = chtatab[evalr[0].value];
  465.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  466.                     }
  467.                     else
  468.                     {
  469.             fraerror("nonexistent character translation table");
  470.                     }
  471.                 }
  472.                 else
  473.                 {
  474.                     fraerror("noncomputable expression");
  475.                 }
  476.             }
  477.     |        KOC_CHDEF STRING ',' exprlist
  478.             {
  479.         int findrv, numret, *charaddr;
  480.         char *sourcestr = $2, *before;
  481.  
  482.         if(chtnpoint != (int *)NULL)
  483.         {
  484.             for(satsub = 0; satsub < $4; satsub++)
  485.             {
  486.                 before = sourcestr;
  487.  
  488.                 pevalexpr(0, exprlist[satsub]);
  489.                 findrv = chtcfind(chtnpoint, &sourcestr,
  490.                         &charaddr, &numret);
  491.                 if(findrv == CF_END)
  492.                 {
  493.             fraerror("more expressions than characters");
  494.                     break;
  495.                 }
  496.  
  497.                 if(evalr[0].seg == SSG_ABS)
  498.                 {
  499.                     switch(findrv)
  500.                     {
  501.                     case CF_UNDEF:
  502.                         {
  503.                 if(evalr[0].value < 0 ||
  504.                     evalr[0].value > 255)
  505.                 {
  506.             frawarn("character translation value truncated");
  507.                 }
  508.                 *charaddr = evalr[0].value & 0xff;
  509.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  510.                         }
  511.                         break;
  512.  
  513.                     case CF_INVALID:
  514.                     case CF_NUMBER:
  515.                 fracherror("invalid character to define", 
  516.                     before, sourcestr);
  517.                         break;
  518.  
  519.                     case CF_CHAR:
  520.                 fracherror("character already defined", 
  521.                     before, sourcestr);
  522.                         break;
  523.                     }
  524.                 }
  525.                 else
  526.                 {
  527.                     fraerror("noncomputable expression");
  528.                 }
  529.             }
  530.  
  531.             if( *sourcestr != '\0')
  532.             {
  533.                 fraerror("more characters than expressions");
  534.             }
  535.         }
  536.         else
  537.         {
  538.             fraerror("no CHARSET statement active");
  539.         }
  540.             
  541.             }
  542.     |    LABEL 
  543.             {
  544.             if($1 -> seg == SSG_UNDEF)
  545.             {
  546.                 $1 -> seg = SSG_ABS;
  547.                 $1 -> value = labelloc;
  548.                 prtequvalue("C: 0x%lx\n", labelloc);
  549.  
  550.             }
  551.             else
  552.                 fraerror(
  553.                 "multiple definition of label");
  554.             }
  555.     |    labeledline
  556.     ;
  557.  
  558. labeledline :    LABEL genline
  559.             {
  560.             if($1 -> seg == SSG_UNDEF)
  561.             {
  562.                 $1 -> seg = SSG_ABS;
  563.                 $1 -> value = labelloc;
  564.             }
  565.             else
  566.                 fraerror(
  567.                 "multiple definition of label");
  568.             labelloc = locctr;
  569.             }
  570.                 
  571.     |    genline
  572.             {
  573.                 labelloc = locctr;
  574.             }
  575.     ;
  576.  
  577. genline    :    KOC_BDEF    exprlist 
  578.             {
  579.                 genlocrec(currseg, labelloc);
  580.                 for( satsub = 0; satsub < $2; satsub++)
  581.                 {
  582.                     pevalexpr(1, exprlist[satsub]);
  583.                     locctr += geninstr(genbdef);
  584.                 }
  585.             }
  586.     |    KOC_SDEF stringlist 
  587.             {
  588.                 genlocrec(currseg, labelloc);
  589.                 for(satsub = 0; satsub < $2; satsub++)
  590.                 {
  591.                     locctr += genstring(stringlist[satsub]);
  592.                 }
  593.             }
  594.     |    KOC_WDEF exprlist 
  595.             {
  596.                 genlocrec(currseg, labelloc);
  597.                 for( satsub = 0; satsub < $2; satsub++)
  598.                 {
  599.                     pevalexpr(1, exprlist[satsub]);
  600.                     locctr += geninstr(genwdef);
  601.                 }
  602.             }    
  603.     |    KOC_RESM expr 
  604.             {
  605.                 pevalexpr(0, $2);
  606.                 if(evalr[0].seg == SSG_ABS)
  607.                 {
  608.                     locctr = labelloc + evalr[0].value;
  609.                     prtequvalue("C: 0x%lx\n", labelloc);
  610.                 }
  611.                 else
  612.                 {
  613.                     fraerror(
  614.                  "noncomputable result for RMB expression");
  615.                 }
  616.             }
  617.     ;
  618.  
  619. exprlist :    exprlist ',' expr
  620.             {
  621.                 exprlist[nextexprs ++ ] = $3;
  622.                 $$ = nextexprs;
  623.             }
  624.     |    expr
  625.             {
  626.                 nextexprs = 0;
  627.                 exprlist[nextexprs ++ ] = $1;
  628.                 $$ = nextexprs;
  629.             }
  630.     ;
  631.  
  632. stringlist :    stringlist ',' STRING
  633.             {
  634.                 stringlist[nextstrs ++ ] = $3;
  635.                 $$ = nextstrs;
  636.             }
  637.     |    STRING
  638.             {
  639.                 nextstrs = 0;
  640.                 stringlist[nextstrs ++ ] = $1;
  641.                 $$ = nextstrs;
  642.             }
  643.     ;
  644.  
  645.  
  646. line    :    KOC_CPU STRING
  647.             {
  648.         if( ! cpumatch($2))
  649.         {
  650.             fraerror("unknown cpu type, 80C50 assumed");
  651.             cpuselect = CPU80C50;
  652.         }
  653.             }
  654.     ;
  655. line :        LABEL KOC_REG expr 
  656.         {
  657.             if($1 -> seg == SSG_UNDEF
  658.                || $1 -> seg == SSG_SET)
  659.             {
  660.                 pevalexpr(0, $3);
  661.                 if(evalr[0].seg == SSG_ABS)
  662.                 {
  663.                     switch(cpuselect & RAMSIZEMASK)
  664.                     {
  665.                     case RAMSIZE64:
  666.                         if(evalr[0].value < 0 ||
  667.                            evalr[0].value > 63)
  668.                         {
  669.                             fraerror(
  670.                     "unimplemented register address");
  671.                         }
  672.                         break;
  673.  
  674.                     case RAMSIZE128:
  675.                         if(evalr[0].value < 0 ||
  676.                            evalr[0].value > 127)
  677.                         {
  678.                             fraerror(
  679.                     "unimplemented register address");
  680.                         }
  681.                         break;
  682.  
  683.                     case RAMSIZE256:
  684.                         if(evalr[0].value < 0 ||
  685.                            evalr[0].value > 255)
  686.                         {
  687.                             fraerror(
  688.                     "unimplemented register address");
  689.                         }
  690.                         break;
  691.  
  692.                     default:
  693.                         break;
  694.                     }
  695.  
  696.                     $1 -> seg = SSG_SET;
  697.                     $1 -> value = evalr[0].value;
  698.                     prtequvalue("C: 0x%lx\n",
  699.                         evalr[0].value);
  700.                 }
  701.                 else
  702.                 {
  703.                     fraerror(
  704.                 "noncomputable expression for REGISTER SET");
  705.                 }
  706.             }
  707.             else
  708.             {
  709.                 fraerror(
  710.             "cannot change symbol value with REGISTER SET");
  711.             }
  712.         }
  713.     ;
  714. genline : KOC_opcode  AF
  715.             {
  716.         genlocrec(currseg, labelloc);
  717.         locctr += geninstr(findgen($1, ST_AF,  $2|cpuselect));
  718.             }
  719.     ;
  720. genline : KOC_opcode  REG
  721.             {
  722.         genlocrec(currseg, labelloc);
  723.         evalr[1].value = $2;
  724.         locctr += geninstr(findgen($1, ST_REG,  cpuselect));
  725.             }
  726.     ;
  727. genline : KOC_opcode  expr
  728.             {
  729.         genlocrec(currseg, labelloc);
  730.         pevalexpr(1, $2);
  731.         locctr += geninstr(findgen($1, ST_EXPR,  cpuselect));
  732.             }
  733.     ;
  734. genline : KOC_opcode  AF ',' REG
  735.             {
  736.         genlocrec(currseg, labelloc);
  737.         evalr[1].value = $4;
  738.         locctr += geninstr(findgen($1, ST_AR,  $2|cpuselect));
  739.             }
  740.     ;
  741. genline : KOC_opcode  AF ',' '@' REG
  742.             {
  743.         genlocrec(currseg, labelloc);
  744.         if($5 > 1)
  745.         {
  746.             fraerror("invalid register for indirect mode");
  747.             evalr[1].value = 0;
  748.         }
  749.         else
  750.         {
  751.             evalr[1].value = $5;
  752.         }
  753.         locctr += geninstr(findgen($1, ST_AINDIRR,  $2|cpuselect));
  754.             }
  755.     ;
  756. genline : KOC_opcode  AF ',' '#' expr
  757.             {
  758.         genlocrec(currseg, labelloc);
  759.         pevalexpr(1, $5);
  760.         locctr += geninstr(findgen($1, ST_AIMMED,  $2|cpuselect));
  761.             }
  762.     ;
  763. genline : KOC_opcode  '@' AF
  764.             {
  765.         genlocrec(currseg, labelloc);
  766.         locctr += geninstr(findgen($1, ST_INDIRA,  $3|cpuselect));
  767.             }
  768.     ;
  769. genline : KOC_opcode  '@' REG
  770.             {
  771.         genlocrec(currseg, labelloc);
  772.         if($3 > 1)
  773.         {
  774.             fraerror("invalid register for indirect mode");
  775.             evalr[1].value = 0;
  776.         }
  777.         else
  778.         {
  779.             evalr[1].value = $3;
  780.         }
  781.         locctr += geninstr(findgen($1, ST_INDIRR,  cpuselect));
  782.             }
  783.     ;
  784. genline : KOC_opcode  REG ',' expr
  785.             {
  786.         genlocrec(currseg, labelloc);
  787.         evalr[1].value = $2;
  788.         pevalexpr(2, $4);
  789.         locctr += geninstr(findgen($1, ST_REGEXP,  cpuselect));
  790.             }
  791.     ;
  792. genline : KOC_opcode  AF ',' P02
  793.             {
  794.         genlocrec(currseg, labelloc);
  795.         locctr += geninstr(findgen($1, ST_PA2,  $2 | $4|cpuselect));
  796.             }
  797.     ;
  798. genline : KOC_opcode  AF ',' P47 
  799.             {
  800.         genlocrec(currseg, labelloc);
  801.         evalr[1].value = $4;
  802.         locctr += geninstr(findgen($1, ST_PA4,  $2|cpuselect));
  803.             }
  804.     ;
  805. genline : KOC_opcode  P02 ',' AF
  806.             {
  807.         genlocrec(currseg, labelloc);
  808.         locctr += geninstr(findgen($1, ST_P2A,  $2 | $4|cpuselect));
  809.             }
  810.     ;
  811. genline : KOC_opcode  P47 ',' AF
  812.             {
  813.         genlocrec(currseg, labelloc);
  814.         evalr[1].value = $2;
  815.         locctr += geninstr(findgen($1, ST_P4A,  $4|cpuselect));
  816.             }
  817.     ;
  818. genline : KOC_opcode  P02 ',' '#' expr
  819.             {
  820.         genlocrec(currseg, labelloc);
  821.         pevalexpr(1, $5);
  822.         locctr += geninstr(findgen($1, ST_P2IMMED,  $2|cpuselect));
  823.             }
  824.     ;
  825. genline : KOC_misc 
  826.             {
  827.         genlocrec(currseg, labelloc);
  828.         locctr += geninstr(findgen($1, ST_INH,  cpuselect));
  829.             }
  830.     ;
  831. genline : KOC_misc  INT
  832.             {
  833.         genlocrec(currseg, labelloc);
  834.         locctr += geninstr(findgen($1, ST_INT,  $2|cpuselect));
  835.             }
  836.     ;
  837. genline : KOC_misc  RSELC
  838.             {
  839.         genlocrec(currseg, labelloc);
  840.         evalr[1].value = $2 << 4;
  841.         locctr += geninstr(findgen($1, ST_RSELC,  cpuselect));
  842.             }
  843.     ;
  844. genline : KOC_misc  MSELC
  845.             {
  846.         genlocrec(currseg, labelloc);
  847.         evalr[1].value = $2 << 4;
  848.         locctr += geninstr(findgen($1, ST_MSELC,  cpuselect));
  849.             }
  850.     ;
  851. genline : KOC_misc  MREG
  852.             {
  853.         genlocrec(currseg, labelloc);
  854.         locctr += geninstr(findgen($1, ST_MREG,  $2|cpuselect));
  855.             }
  856.     ;
  857. genline : KOC_mov  AF ',' REG
  858.             {
  859.         genlocrec(currseg, labelloc);
  860.         evalr[1].value = $4;
  861.         locctr += geninstr(findgen($1, ST_MAR,  $2|cpuselect));
  862.             }
  863.     ;
  864. genline : KOC_mov  AF ',' '@' AF
  865.             {
  866.         genlocrec(currseg, labelloc);
  867.         locctr += geninstr(findgen($1, ST_MAINDIRA,  $2|$5|cpuselect));
  868.             }
  869.     ;
  870. genline : KOC_mov  AF ',' '@' REG
  871.             {
  872.         genlocrec(currseg, labelloc);
  873.         if($5 > 1)
  874.         {
  875.             fraerror("invalid register for indirect mode");
  876.             evalr[1].value = 0;
  877.         }
  878.         else
  879.         {
  880.             evalr[1].value = $5;
  881.         }
  882.         locctr += geninstr(findgen($1, ST_MAINDIRR,  $2|cpuselect));
  883.             }
  884.     ;
  885. genline : KOC_mov  AF ',' '#' expr
  886.             {
  887.         genlocrec(currseg, labelloc);
  888.         pevalexpr(1, $5);
  889.         locctr += geninstr(findgen($1, ST_MAIMMED,  $2|cpuselect));
  890.             }
  891.     ;
  892. genline : KOC_mov  AF ',' MREG
  893.             {
  894.         genlocrec(currseg, labelloc);
  895.         locctr += geninstr(findgen($1, ST_MAMR,  $2 | $4|cpuselect));
  896.             }
  897.     ;
  898. genline : KOC_mov  MREG ',' AF
  899.             {
  900.         genlocrec(currseg, labelloc);
  901.         locctr += geninstr(findgen($1, ST_MMRA,  $2 | $4|cpuselect));
  902.             }
  903.     ;
  904. genline : KOC_mov  REG ',' AF
  905.             {
  906.         genlocrec(currseg, labelloc);
  907.         evalr[1].value = $2;
  908.         locctr += geninstr(findgen($1, ST_MRA,  $4|cpuselect));
  909.             }
  910.     ;
  911. genline : KOC_mov  REG ',' '#' expr
  912.             {
  913.         genlocrec(currseg, labelloc);
  914.         evalr[1].value = $2;
  915.         pevalexpr(2, $5);
  916.         locctr += geninstr(findgen($1, ST_MRIMMED,  cpuselect));
  917.             }
  918.     ;
  919. genline : KOC_mov  '@' REG ',' AF
  920.             {
  921.         genlocrec(currseg, labelloc);
  922.         if($3 > 1)
  923.         {
  924.             fraerror("invalid register for indirect mode");
  925.             evalr[1].value = 0;
  926.         }
  927.         else
  928.         {
  929.             evalr[1].value = $3;
  930.         }
  931.         locctr += geninstr(findgen($1, ST_MINDIRRA,  $5|cpuselect));
  932.             }
  933.     ;
  934. genline : KOC_mov  '@' REG ',' '#' expr
  935.             {
  936.         genlocrec(currseg, labelloc);
  937.         if($3 > 1)
  938.         {
  939.             fraerror("invalid register for indirect mode");
  940.             evalr[1].value = 0;
  941.         }
  942.         else
  943.         {
  944.             evalr[1].value = $3;
  945.         }
  946.         pevalexpr(2, $6);
  947.         locctr += geninstr(findgen($1, ST_MINDIRRIM,  cpuselect));
  948.             }
  949.     ;
  950. expr    :    '+' expr %prec KEOP_MUN
  951.             {
  952.                 $$ = $2;
  953.             }
  954.     |    '-' expr %prec KEOP_MUN
  955.             {
  956.                 $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
  957.                     SYMNULL);
  958.             }
  959.     |    KEOP_NOT expr
  960.             {
  961.                 $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
  962.                     SYMNULL);
  963.             }
  964.     |    KEOP_HIGH expr
  965.             {
  966.                 $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
  967.                     SYMNULL);
  968.             }
  969.     |    KEOP_LOW expr
  970.             {
  971.                 $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
  972.                     SYMNULL);
  973.             }
  974.     |    expr '*' expr
  975.             {
  976.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
  977.                     SYMNULL);
  978.             }
  979.     |    expr '/' expr
  980.             {
  981.                 $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
  982.                     SYMNULL);
  983.             }
  984.     |    expr '+' expr
  985.             {
  986.                 $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
  987.                     SYMNULL);
  988.             }
  989.     |    expr '-' expr
  990.             {
  991.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
  992.                     SYMNULL);
  993.             }
  994.     |    expr KEOP_MOD expr
  995.             {
  996.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
  997.                     SYMNULL);
  998.             }
  999.     |    expr KEOP_SHL expr
  1000.             {
  1001.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
  1002.                     SYMNULL);
  1003.             }
  1004.     |    expr KEOP_SHR expr
  1005.             {
  1006.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
  1007.                     SYMNULL);
  1008.             }
  1009.     |    expr KEOP_GT expr
  1010.             {
  1011.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
  1012.                     SYMNULL);
  1013.             }
  1014.     |    expr KEOP_GE expr
  1015.             {
  1016.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
  1017.                     SYMNULL);
  1018.             }
  1019.     |    expr KEOP_LT expr
  1020.             {
  1021.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
  1022.                     SYMNULL);
  1023.             }
  1024.     |    expr KEOP_LE expr
  1025.             {
  1026.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
  1027.                     SYMNULL);
  1028.             }
  1029.     |    expr KEOP_NE expr
  1030.             {
  1031.                 $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
  1032.                     SYMNULL);
  1033.             }
  1034.     |    expr KEOP_EQ expr
  1035.             {
  1036.                 $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
  1037.                     SYMNULL);
  1038.             }
  1039.     |    expr KEOP_AND expr
  1040.             {
  1041.                 $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
  1042.                     SYMNULL);
  1043.             }
  1044.     |    expr KEOP_OR expr
  1045.             {
  1046.                 $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
  1047.                     SYMNULL);
  1048.             }
  1049.     |    expr KEOP_XOR expr
  1050.             {
  1051.                 $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
  1052.                     SYMNULL);
  1053.             }
  1054.     |    KEOP_DEFINED SYMBOL
  1055.             {
  1056.                 $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
  1057.             }
  1058.     |    SYMBOL
  1059.             {
  1060.                 $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
  1061.             }
  1062.     |    '*'
  1063.             {
  1064.                 $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
  1065.                     labelloc, SYMNULL);
  1066.             }
  1067.     |    CONSTANT
  1068.             {
  1069.                 $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
  1070.                     SYMNULL);
  1071.             }
  1072.     |    STRING
  1073.             {
  1074.                 char *sourcestr = $1;
  1075.                 long accval = 0;
  1076.  
  1077.                 if(strlen($1) > 0)
  1078.                 {
  1079.                     accval = chtran(&sourcestr);
  1080.                     if(*sourcestr != '\0')
  1081.                     {
  1082.                         accval = (accval << 8) +
  1083.                             chtran(&sourcestr);
  1084.                     }
  1085.  
  1086.                     if( *sourcestr != '\0')
  1087.                     {
  1088.     frawarn("string constant in expression more than 2 characters long");
  1089.                     }
  1090.                 }
  1091.                 $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
  1092.                     accval, SYMNULL);
  1093.             }
  1094.     |    '(' expr ')'
  1095.             {
  1096.                 $$ = $2;
  1097.             }
  1098.     ;
  1099.  
  1100.  
  1101.  
  1102. %%
  1103.  
  1104. lexintercept()
  1105. /*
  1106.     description    intercept the call to yylex (the lexical analyzer)
  1107.             and filter out all unnecessary tokens when skipping
  1108.             the input between a failed IF and its matching ENDI or
  1109.             ELSE
  1110.     globals     fraifskip    the enable flag
  1111. */
  1112. {
  1113. #undef yylex
  1114.  
  1115.     int rv;
  1116.  
  1117.     if(fraifskip)
  1118.     {
  1119.         for(;;)
  1120.         {
  1121.  
  1122.             switch(rv = yylex())
  1123.  
  1124.             {
  1125.             case 0:
  1126.             case KOC_END:
  1127.             case KOC_IF:
  1128.             case KOC_ELSE:
  1129.             case KOC_ENDI:
  1130.             case EOL:
  1131.                 return rv;
  1132.             default:
  1133.                 break;
  1134.             }
  1135.         }
  1136.     }
  1137.     else
  1138.         return yylex();
  1139. #define yylex lexintercept
  1140. }
  1141.  
  1142.  
  1143.  
  1144. setreserved()
  1145. {
  1146.  
  1147.     reservedsym("and", KEOP_AND, 0);
  1148.     reservedsym("defined", KEOP_DEFINED,0);
  1149.     reservedsym("eq", KEOP_EQ, 0);
  1150.     reservedsym("ge", KEOP_GE, 0);
  1151.     reservedsym("gt", KEOP_GT, 0);
  1152.     reservedsym("high", KEOP_HIGH, 0);
  1153.     reservedsym("le", KEOP_LE, 0);
  1154.     reservedsym("low", KEOP_LOW, 0);
  1155.     reservedsym("lt", KEOP_LT, 0);
  1156.     reservedsym("mod", KEOP_MOD, 0);
  1157.     reservedsym("ne", KEOP_NE, 0);
  1158.     reservedsym("not", KEOP_NOT, 0);
  1159.     reservedsym("or", KEOP_OR, 0);
  1160.     reservedsym("shl", KEOP_SHL, 0);
  1161.     reservedsym("shr", KEOP_SHR, 0);
  1162.     reservedsym("xor", KEOP_XOR, 0);
  1163.     reservedsym("AND", KEOP_AND, 0);
  1164.     reservedsym("DEFINED", KEOP_DEFINED,0);
  1165.     reservedsym("EQ", KEOP_EQ, 0);
  1166.     reservedsym("GE", KEOP_GE, 0);
  1167.     reservedsym("GT", KEOP_GT, 0);
  1168.     reservedsym("HIGH", KEOP_HIGH, 0);
  1169.     reservedsym("LE", KEOP_LE, 0);
  1170.     reservedsym("LOW", KEOP_LOW, 0);
  1171.     reservedsym("LT", KEOP_LT, 0);
  1172.     reservedsym("MOD", KEOP_MOD, 0);
  1173.     reservedsym("NE", KEOP_NE, 0);
  1174.     reservedsym("NOT", KEOP_NOT, 0);
  1175.     reservedsym("OR", KEOP_OR, 0);
  1176.     reservedsym("SHL", KEOP_SHL, 0);
  1177.     reservedsym("SHR", KEOP_SHR, 0);
  1178.     reservedsym("XOR", KEOP_XOR, 0);
  1179.  
  1180.     /* machine specific token definitions */
  1181.     reservedsym("RB0", RSELC, 0);
  1182.     reservedsym("RB1", RSELC, 1);
  1183.     reservedsym("MB0", MSELC, 2);
  1184.     reservedsym("MB1", MSELC, 3);
  1185.     reservedsym("I", INT, ISELI);
  1186.     reservedsym("TCNTI", INT, ISELTCNTI);
  1187.     reservedsym("A", AF, AFSELA);
  1188.     reservedsym("C", AF, AFSELC);
  1189.     reservedsym("F0", AF, AFSELF0);
  1190.     reservedsym("F1", AF, AFSELF1);
  1191.     reservedsym("R0", REG, 0);
  1192.     reservedsym("R1", REG, 1);
  1193.     reservedsym("R2", REG, 2);
  1194.     reservedsym("R3", REG, 3);
  1195.     reservedsym("R4", REG, 4);
  1196.     reservedsym("R5", REG, 5);
  1197.     reservedsym("R6", REG, 6);
  1198.     reservedsym("R7", REG, 7);
  1199.     reservedsym("BUS", P02, PSELBUS);
  1200.     reservedsym("P1", P02, PSELP1);
  1201.     reservedsym("P2", P02, PSELP2);
  1202.     reservedsym("P4", P47, 0);
  1203.     reservedsym("P5", P47, 1);
  1204.     reservedsym("P6", P47, 2);
  1205.     reservedsym("P7", P47, 3);
  1206.     reservedsym("PSW", MREG, MSELPSW);
  1207.     reservedsym("T", MREG, MSELT);
  1208.     reservedsym("CNT", MREG, MSELCNT);
  1209.     reservedsym("TCNT", MREG, MSELTCNT);
  1210.     reservedsym("CLK", MREG, MSELCLK);
  1211.     reservedsym("DMA", INT, ISELDMA);
  1212.     reservedsym("FLAGS", INT, ISELFLAGS);
  1213.     reservedsym("DBB", P02, PSELDBB);
  1214.     reservedsym("STS", MREG, MSELSTS);
  1215.     reservedsym("rb0", RSELC, 0);
  1216.     reservedsym("rb1", RSELC, 1);
  1217.     reservedsym("mb0", MSELC, 2);
  1218.     reservedsym("mb1", MSELC, 3);
  1219.     reservedsym("i", INT, ISELI);
  1220.     reservedsym("tcnti", INT, ISELTCNTI);
  1221.     reservedsym("a", AF, AFSELA);
  1222.     reservedsym("c", AF, AFSELC);
  1223.     reservedsym("f0", AF, AFSELF0);
  1224.     reservedsym("f1", AF, AFSELF1);
  1225.     reservedsym("r0", REG, 0);
  1226.     reservedsym("r1", REG, 1);
  1227.     reservedsym("r2", REG, 2);
  1228.     reservedsym("r3", REG, 3);
  1229.     reservedsym("r4", REG, 4);
  1230.     reservedsym("r5", REG, 5);
  1231.     reservedsym("r6", REG, 6);
  1232.     reservedsym("r7", REG, 7);
  1233.     reservedsym("bus", P02, PSELBUS);
  1234.     reservedsym("p1", P02, PSELP1);
  1235.     reservedsym("p2", P02, PSELP2);
  1236.     reservedsym("p4", P47, 0);
  1237.     reservedsym("p5", P47, 1);
  1238.     reservedsym("p6", P47, 2);
  1239.     reservedsym("p7", P47, 3);
  1240.     reservedsym("psw", MREG, MSELPSW);
  1241.     reservedsym("t", MREG, MSELT);
  1242.     reservedsym("cnt", MREG, MSELCNT);
  1243.     reservedsym("tcnt", MREG, MSELTCNT);
  1244.     reservedsym("clk", MREG, MSELCLK);
  1245.     reservedsym("dma", INT, ISELDMA);
  1246.     reservedsym("flags", INT, ISELFLAGS);
  1247.     reservedsym("dbb", P02, PSELDBB);
  1248.     reservedsym("sts", MREG, MSELSTS);
  1249.  
  1250. }
  1251.  
  1252. cpumatch(str)
  1253.     char * str;
  1254. {
  1255.     int msub;
  1256.  
  1257.     static struct
  1258.     {
  1259.         char * mtch;
  1260.         int   cpuv;
  1261.     } matchtab[] =
  1262.     {
  1263.         {"C48", CPU80C48},
  1264.         {"c48", CPU80C48},
  1265.         {"C35", CPU80C48},
  1266.         {"c35", CPU80C48},
  1267.         {"C49", CPU80C49},
  1268.         {"c49", CPU80C49},
  1269.         {"C39", CPU80C49},
  1270.         {"c39", CPU80C49},
  1271.         {"C50", CPU80C50},
  1272.         {"c50", CPU80C50},
  1273.         {"C40", CPU80C50},
  1274.         {"c40", CPU80C50},
  1275.         {"48", CPU8048},
  1276.         {"35", CPU8048},
  1277.         {"49", CPU8049},
  1278.         {"39", CPU8049},
  1279.         {"50", CPU8050},
  1280.         {"40", CPU8050},
  1281.         {"41", CPU8041},
  1282.         {"42", CPU8042},
  1283.         { "" , 0 }
  1284.     };
  1285.  
  1286.     for(msub = 0; matchtab[msub].mtch[0] != '\0'; msub++)
  1287.     {
  1288.         if(strcontains(str, matchtab[msub].mtch))
  1289.         {
  1290.             cpuselect = matchtab[msub].cpuv;
  1291.             return TRUE;
  1292.         }
  1293.     }
  1294.  
  1295.     return FALSE;
  1296. }
  1297.  
  1298.  
  1299. strcontains(s1, sm)
  1300.     char * s1, *sm;
  1301. {
  1302.     int l1 = strlen(s1), lm = strlen(sm);
  1303.  
  1304.     for(; l1 >= lm; l1--, s1++)
  1305.     {
  1306.         if(strncmp(s1, sm, lm) == 0)
  1307.         {
  1308.             return TRUE;
  1309.         }
  1310.     }
  1311.     return FALSE;
  1312. }
  1313.  
  1314. /*
  1315.     description    Opcode and Instruction generation tables
  1316.     usage        Unix, framework crossassembler
  1317.     history        September 25, 1987
  1318. */
  1319.  
  1320. #define NUMOPCODE 91
  1321. #define NUMSYNBLK 94
  1322. #define NUMDIFFOP 116
  1323.  
  1324. int gnumopcode = NUMOPCODE;
  1325.  
  1326. int ophashlnk[NUMOPCODE];
  1327.  
  1328. struct opsym optab[NUMOPCODE+1]
  1329.     = {
  1330.     {"invalid", KOC_opcode, 2, 0 },
  1331.     {"ADD", KOC_opcode, 3, 2 },
  1332.     {"ADDC", KOC_opcode, 3, 5 },
  1333.     {"ANL", KOC_opcode, 4, 8 },
  1334.     {"ANLD", KOC_opcode, 1, 12 },
  1335.     {"BYTE", KOC_BDEF, 0, 0 },
  1336.     {"CALL", KOC_opcode, 1, 13 },
  1337.     {"CHARDEF", KOC_CHDEF, 0, 0 },
  1338.     {"CHARSET", KOC_CHSET, 0, 0 },
  1339.     {"CHARUSE", KOC_CHUSE, 0, 0 },
  1340.     {"CHD", KOC_CHDEF, 0, 0 },
  1341.     {"CLR", KOC_opcode, 1, 14 },
  1342.     {"CPL", KOC_opcode, 1, 15 },
  1343.     {"CPU", KOC_CPU, 0, 0 },
  1344.     {"DA", KOC_opcode, 1, 16 },
  1345.     {"DB", KOC_BDEF, 0, 0 },
  1346.     {"DEC", KOC_opcode, 2, 17 },
  1347.     {"DIS", KOC_misc, 1, 19 },
  1348.     {"DJNZ", KOC_opcode, 1, 20 },
  1349.     {"DW", KOC_WDEF, 0, 0 },
  1350.     {"ELSE", KOC_ELSE, 0, 0 },
  1351.     {"EN", KOC_misc, 1, 21 },
  1352.     {"END", KOC_END, 0, 0 },
  1353.     {"ENDI", KOC_ENDI, 0, 0 },
  1354.     {"ENT0", KOC_misc, 1, 22 },
  1355.     {"EQU", KOC_EQU, 0, 0 },
  1356.     {"FCB", KOC_BDEF, 0, 0 },
  1357.     {"FCC", KOC_SDEF, 0, 0 },
  1358.     {"FDB", KOC_WDEF, 0, 0 },
  1359.     {"HALT", KOC_misc, 1, 23 },
  1360.     {"IDL", KOC_misc, 1, 24 },
  1361.     {"IF", KOC_IF, 0, 0 },
  1362.     {"IN", KOC_opcode, 1, 25 },
  1363.     {"INC", KOC_opcode, 3, 26 },
  1364.     {"INCL", KOC_INCLUDE, 0, 0 },
  1365.     {"INCLUDE", KOC_INCLUDE, 0, 0 },
  1366.     {"INS", KOC_opcode, 1, 29 },
  1367.     {"JB0", KOC_opcode, 1, 30 },
  1368.     {"JB1", KOC_opcode, 1, 31 },
  1369.     {"JB2", KOC_opcode, 1, 32 },
  1370.     {"JB3", KOC_opcode, 1, 33 },
  1371.     {"JB4", KOC_opcode, 1, 34 },
  1372.     {"JB5", KOC_opcode, 1, 35 },
  1373.     {"JB6", KOC_opcode, 1, 36 },
  1374.     {"JB7", KOC_opcode, 1, 37 },
  1375.     {"JC", KOC_opcode, 1, 38 },
  1376.     {"JF0", KOC_opcode, 1, 39 },
  1377.     {"JF1", KOC_opcode, 1, 40 },
  1378.     {"JMP", KOC_opcode, 1, 41 },
  1379.     {"JMPP", KOC_opcode, 1, 42 },
  1380.     {"JNC", KOC_opcode, 1, 43 },
  1381.     {"JNI", KOC_opcode, 1, 44 },
  1382.     {"JNIBF", KOC_opcode, 1, 45 },
  1383.     {"JNT0", KOC_opcode, 1, 46 },
  1384.     {"JNT1", KOC_opcode, 1, 47 },
  1385.     {"JNZ", KOC_opcode, 1, 48 },
  1386.     {"JOBF", KOC_opcode, 1, 49 },
  1387.     {"JT0", KOC_opcode, 1, 50 },
  1388.     {"JT1", KOC_opcode, 1, 51 },
  1389.     {"JTF", KOC_opcode, 1, 52 },
  1390.     {"JZ", KOC_opcode, 1, 53 },
  1391.     {"MOV", KOC_mov, 9, 54 },
  1392.     {"MOVD", KOC_opcode, 2, 63 },
  1393.     {"MOVP3", KOC_mov, 1, 65 },
  1394.     {"MOVP", KOC_mov, 1, 66 },
  1395.     {"MOVX", KOC_mov, 2, 67 },
  1396.     {"NOP", KOC_misc, 1, 69 },
  1397.     {"ORG", KOC_ORG, 0, 0 },
  1398.     {"ORL", KOC_opcode, 4, 70 },
  1399.     {"ORLD", KOC_opcode, 1, 74 },
  1400.     {"OUT", KOC_opcode, 1, 75 },
  1401.     {"OUTL", KOC_opcode, 1, 76 },
  1402.     {"REGISTER", KOC_REG, 0, 0 },
  1403.     {"RESERVE", KOC_RESM, 0, 0 },
  1404.     {"RET", KOC_misc, 1, 77 },
  1405.     {"RETR", KOC_misc, 1, 78 },
  1406.     {"RL", KOC_opcode, 1, 79 },
  1407.     {"RLC", KOC_opcode, 1, 80 },
  1408.     {"RMB", KOC_RESM, 0, 0 },
  1409.     {"RR", KOC_opcode, 1, 81 },
  1410.     {"RRC", KOC_opcode, 1, 82 },
  1411.     {"SEL", KOC_misc, 2, 83 },
  1412.     {"SET", KOC_SET, 0, 0 },
  1413.     {"STOP", KOC_misc, 1, 85 },
  1414.     {"STRING", KOC_SDEF, 0, 0 },
  1415.     {"STRT", KOC_misc, 1, 86 },
  1416.     {"SWAP", KOC_opcode, 1, 87 },
  1417.     {"WORD", KOC_WDEF, 0, 0 },
  1418.     {"XCH", KOC_opcode, 2, 88 },
  1419.     {"XCHD", KOC_opcode, 1, 90 },
  1420.     {"XRL", KOC_opcode, 3, 91 },
  1421.     { "", 0, 0, 0 }};
  1422.  
  1423. struct opsynt ostab[NUMSYNBLK+1]
  1424.     = {
  1425. /* invalid 0 */ { 0, 1, 0 },
  1426. /* invalid 1 */ { 0xffff, 1, 1 },
  1427. /* ADD 2 */ { ST_AIMMED, 1, 2 },
  1428. /* ADD 3 */ { ST_AINDIRR, 1, 3 },
  1429. /* ADD 4 */ { ST_AR, 1, 4 },
  1430. /* ADDC 5 */ { ST_AIMMED, 1, 5 },
  1431. /* ADDC 6 */ { ST_AINDIRR, 1, 6 },
  1432. /* ADDC 7 */ { ST_AR, 1, 7 },
  1433. /* ANL 8 */ { ST_AIMMED, 1, 8 },
  1434. /* ANL 9 */ { ST_AINDIRR, 1, 9 },
  1435. /* ANL 10 */ { ST_AR, 1, 10 },
  1436. /* ANL 11 */ { ST_P2IMMED, 3, 11 },
  1437. /* ANLD 12 */ { ST_P4A, 1, 14 },
  1438. /* CALL 13 */ { ST_EXPR, 1, 15 },
  1439. /* CLR 14 */ { ST_AF, 4, 16 },
  1440. /* CPL 15 */ { ST_AF, 4, 20 },
  1441. /* DA 16 */ { ST_AF, 1, 24 },
  1442. /* DEC 17 */ { ST_AF, 1, 25 },
  1443. /* DEC 18 */ { ST_REG, 1, 26 },
  1444. /* DIS 19 */ { ST_INT, 2, 27 },
  1445. /* DJNZ 20 */ { ST_REGEXP, 1, 29 },
  1446. /* EN 21 */ { ST_INT, 4, 30 },
  1447. /* ENT0 22 */ { ST_MREG, 1, 34 },
  1448. /* HALT 23 */ { ST_INH, 1, 35 },
  1449. /* IDL 24 */ { ST_INH, 1, 36 },
  1450. /* IN 25 */ { ST_PA2, 3, 37 },
  1451. /* INC 26 */ { ST_AF, 1, 40 },
  1452. /* INC 27 */ { ST_INDIRR, 1, 41 },
  1453. /* INC 28 */ { ST_REG, 1, 42 },
  1454. /* INS 29 */ { ST_PA2, 1, 43 },
  1455. /* JB0 30 */ { ST_EXPR, 1, 44 },
  1456. /* JB1 31 */ { ST_EXPR, 1, 45 },
  1457. /* JB2 32 */ { ST_EXPR, 1, 46 },
  1458. /* JB3 33 */ { ST_EXPR, 1, 47 },
  1459. /* JB4 34 */ { ST_EXPR, 1, 48 },
  1460. /* JB5 35 */ { ST_EXPR, 1, 49 },
  1461. /* JB6 36 */ { ST_EXPR, 1, 50 },
  1462. /* JB7 37 */ { ST_EXPR, 1, 51 },
  1463. /* JC 38 */ { ST_EXPR, 1, 52 },
  1464. /* JF0 39 */ { ST_EXPR, 1, 53 },
  1465. /* JF1 40 */ { ST_EXPR, 1, 54 },
  1466. /* JMP 41 */ { ST_EXPR, 1, 55 },
  1467. /* JMPP 42 */ { ST_INDIRA, 1, 56 },
  1468. /* JNC 43 */ { ST_EXPR, 1, 57 },
  1469. /* JNI 44 */ { ST_EXPR, 1, 58 },
  1470. /* JNIBF 45 */ { ST_EXPR, 1, 59 },
  1471. /* JNT0 46 */ { ST_EXPR, 1, 60 },
  1472. /* JNT1 47 */ { ST_EXPR, 1, 61 },
  1473. /* JNZ 48 */ { ST_EXPR, 1, 62 },
  1474. /* JOBF 49 */ { ST_EXPR, 1, 63 },
  1475. /* JT0 50 */ { ST_EXPR, 1, 64 },
  1476. /* JT1 51 */ { ST_EXPR, 1, 65 },
  1477. /* JTF 52 */ { ST_EXPR, 1, 66 },
  1478. /* JZ 53 */ { ST_EXPR, 1, 67 },
  1479. /* MOV 54 */ { ST_MAIMMED, 1, 68 },
  1480. /* MOV 55 */ { ST_MAINDIRR, 1, 69 },
  1481. /* MOV 56 */ { ST_MAMR, 2, 70 },
  1482. /* MOV 57 */ { ST_MAR, 1, 72 },
  1483. /* MOV 58 */ { ST_MINDIRRA, 1, 73 },
  1484. /* MOV 59 */ { ST_MINDIRRIM, 1, 74 },
  1485. /* MOV 60 */ { ST_MMRA, 3, 75 },
  1486. /* MOV 61 */ { ST_MRA, 1, 78 },
  1487. /* MOV 62 */ { ST_MRIMMED, 1, 79 },
  1488. /* MOVD 63 */ { ST_P4A, 1, 80 },
  1489. /* MOVD 64 */ { ST_PA4, 1, 81 },
  1490. /* MOVP3 65 */ { ST_MAINDIRA, 1, 82 },
  1491. /* MOVP 66 */ { ST_MAINDIRA, 1, 83 },
  1492. /* MOVX 67 */ { ST_MAINDIRR, 1, 84 },
  1493. /* MOVX 68 */ { ST_MINDIRRA, 1, 85 },
  1494. /* NOP 69 */ { ST_INH, 1, 86 },
  1495. /* ORL 70 */ { ST_AIMMED, 1, 87 },
  1496. /* ORL 71 */ { ST_AINDIRR, 1, 88 },
  1497. /* ORL 72 */ { ST_AR, 1, 89 },
  1498. /* ORL 73 */ { ST_P2IMMED, 3, 90 },
  1499. /* ORLD 74 */ { ST_P4A, 1, 93 },
  1500. /* OUT 75 */ { ST_P2A, 1, 94 },
  1501. /* OUTL 76 */ { ST_P2A, 3, 95 },
  1502. /* RET 77 */ { ST_INH, 1, 98 },
  1503. /* RETR 78 */ { ST_INH, 1, 99 },
  1504. /* RL 79 */ { ST_AF, 1, 100 },
  1505. /* RLC 80 */ { ST_AF, 1, 101 },
  1506. /* RR 81 */ { ST_AF, 1, 102 },
  1507. /* RRC 82 */ { ST_AF, 1, 103 },
  1508. /* SEL 83 */ { ST_MSELC, 1, 104 },
  1509. /* SEL 84 */ { ST_RSELC, 1, 105 },
  1510. /* STOP 85 */ { ST_MREG, 1, 106 },
  1511. /* STRT 86 */ { ST_MREG, 2, 107 },
  1512. /* SWAP 87 */ { ST_AF, 1, 109 },
  1513. /* XCH 88 */ { ST_AINDIRR, 1, 110 },
  1514. /* XCH 89 */ { ST_AR, 1, 111 },
  1515. /* XCHD 90 */ { ST_AINDIRR, 1, 112 },
  1516. /* XRL 91 */ { ST_AIMMED, 1, 113 },
  1517. /* XRL 92 */ { ST_AINDIRR, 1, 114 },
  1518. /* XRL 93 */ { ST_AR, 1, 115 },
  1519.     { 0, 0, 0 } };
  1520.  
  1521. struct igel igtab[NUMDIFFOP+1]
  1522.     = {
  1523. /* invalid 0 */   { 0 , 0, 
  1524.         "[Xnullentry" },
  1525. /* invalid 1 */   { 0 , 0, 
  1526.         "[Xinvalid opcode" },
  1527. /* ADD 2 */   { AFSELMASK , AFSELA, 
  1528.         "03;[1=];" },
  1529. /* ADD 3 */   { AFSELMASK , AFSELA, 
  1530.         "60.[1#]|;" },
  1531. /* ADD 4 */   { AFSELMASK , AFSELA, 
  1532.         "68.[1#]|;" },
  1533. /* ADDC 5 */   { AFSELMASK , AFSELA, 
  1534.         "13;[1=];" },
  1535. /* ADDC 6 */   { AFSELMASK , AFSELA, 
  1536.         "70.[1#]|;" },
  1537. /* ADDC 7 */   { AFSELMASK , AFSELA, 
  1538.         "78.[1#]|;" },
  1539. /* ANL 8 */   { AFSELMASK , AFSELA, 
  1540.         "53;[1=];" },
  1541. /* ANL 9 */   { AFSELMASK , AFSELA, 
  1542.         "50.[1#]|;" },
  1543. /* ANL 10 */   { AFSELMASK , AFSELA, 
  1544.         "58.[1#]|;" },
  1545. /* ANL 11 */   { INSTNOT41|PSELMASK , PSELBUS|INSTNOT41, 
  1546.         "98;[1=];" },
  1547. /* ANL 12 */   { PSELMASK , PSELP1, 
  1548.         "99;[1=];" },
  1549. /* ANL 13 */   { PSELMASK , PSELP2, 
  1550.         "9a;[1=];" },
  1551. /* ANLD 14 */   { AFSELMASK , AFSELA, 
  1552.         "9c.[1#]|;" },
  1553. /* CALL 15 */   { 0 , 0, 
  1554.         "[1=].P.f800&-.bI~.3}.e0&.14|;!.ff&;" },
  1555. /* CLR 16 */   { AFSELMASK , AFSELA, 
  1556.         "27;" },
  1557. /* CLR 17 */   { AFSELMASK , AFSELC, 
  1558.         "97;" },
  1559. /* CLR 18 */   { AFSELMASK , AFSELF0, 
  1560.         "85;" },
  1561. /* CLR 19 */   { AFSELMASK , AFSELF1, 
  1562.         "a5;" },
  1563. /* CPL 20 */   { AFSELMASK , AFSELA, 
  1564.         "37;" },
  1565. /* CPL 21 */   { AFSELMASK , AFSELC, 
  1566.         "a7;" },
  1567. /* CPL 22 */   { AFSELMASK , AFSELF0, 
  1568.         "95;" },
  1569. /* CPL 23 */   { AFSELMASK , AFSELF1, 
  1570.         "b5;" },
  1571. /* DA 24 */   { AFSELMASK , AFSELA, 
  1572.         "57;" },
  1573. /* DEC 25 */   { AFSELMASK , AFSELA, 
  1574.         "07;" },
  1575. /* DEC 26 */   { 0 , 0, 
  1576.         "c8.[1#]|;" },
  1577. /* DIS 27 */   { ISELMASK , ISELI, 
  1578.         "15;" },
  1579. /* DIS 28 */   { ISELMASK , ISELTCNTI, 
  1580.         "35;" },
  1581. /* DJNZ 29 */   { 0 , 0, 
  1582.         "e8.[1#]|;[2=].Q.ff00&-.8I;" },
  1583. /* EN 30 */   { ISELMASK , ISELI, 
  1584.         "05;" },
  1585. /* EN 31 */   { ISELMASK , ISELTCNTI, 
  1586.         "25;" },
  1587. /* EN 32 */   { INST41|ISELMASK , ISELDMA|INST41, 
  1588.         "e5;" },
  1589. /* EN 33 */   { INST41|ISELMASK , ISELFLAGS|INST41, 
  1590.         "f5;" },
  1591. /* ENT0 34 */   { INSTNOT41|MSELMASK , MSELCLK|INSTNOT41, 
  1592.         "75;" },
  1593. /* HALT 35 */   { INSTIDL , INSTIDL, 
  1594.         "01;" },
  1595. /* IDL 36 */   { INSTIDL , INSTIDL, 
  1596.         "01;" },
  1597. /* IN 37 */   { INST41|PSELMASK|AFSELMASK , PSELDBB|AFSELA|INST41, 
  1598.         "22;" },
  1599. /* IN 38 */   { PSELMASK|AFSELMASK , PSELP1|AFSELA, 
  1600.         "09;" },
  1601. /* IN 39 */   { PSELMASK|AFSELMASK , PSELP2|AFSELA, 
  1602.         "0a;" },
  1603. /* INC 40 */   { AFSELMASK , AFSELA, 
  1604.         "17;" },
  1605. /* INC 41 */   { 0 , 0, 
  1606.         "10.[1#]|;" },
  1607. /* INC 42 */   { 0 , 0, 
  1608.         "18.[1#]|;" },
  1609. /* INS 43 */   { INSTNOT41|PSELMASK|AFSELMASK , PSELBUS|AFSELA|INSTNOT41, 
  1610.         "08;" },
  1611. /* JB0 44 */   { 0 , 0, 
  1612.         "12;[1=].Q.ff00&-.8I;" },
  1613. /* JB1 45 */   { 0 , 0, 
  1614.         "32;[1=].Q.ff00&-.8I;" },
  1615. /* JB2 46 */   { 0 , 0, 
  1616.         "52;[1=].Q.ff00&-.8I;" },
  1617. /* JB3 47 */   { 0 , 0, 
  1618.         "72;[1=].Q.ff00&-.8I;" },
  1619. /* JB4 48 */   { 0 , 0, 
  1620.         "92;[1=].Q.ff00&-.8I;" },
  1621. /* JB5 49 */   { 0 , 0, 
  1622.         "b2;[1=].Q.ff00&-.8I;" },
  1623. /* JB6 50 */   { 0 , 0, 
  1624.         "d2;[1=].Q.ff00&-.8I;" },
  1625. /* JB7 51 */   { 0 , 0, 
  1626.         "f2;[1=].Q.ff00&-.8I;" },
  1627. /* JC 52 */   { 0 , 0, 
  1628.         "f6;[1=].Q.ff00&-.8I;" },
  1629. /* JF0 53 */   { 0 , 0, 
  1630.         "b6;[1=].Q.ff00&-.8I;" },
  1631. /* JF1 54 */   { 0 , 0, 
  1632.         "76;[1=].Q.ff00&-.8I;" },
  1633. /* JMP 55 */   { 0 , 0, 
  1634.         "[1=].P.f800&-.bI~.3}.e0&.04|;!.ff&;" },
  1635. /* JMPP 56 */   { AFSELMASK , AFSELA, 
  1636.         "b3;" },
  1637. /* JNC 57 */   { 0 , 0, 
  1638.         "e6;[1=].Q.ff00&-.8I;" },
  1639. /* JNI 58 */   { INSTNOT41 , INSTNOT41, 
  1640.         "86;[1=].Q.ff00&-.8I;" },
  1641. /* JNIBF 59 */   { INST41 , INST41, 
  1642.         "d6;[1=].Q.ff00&-.8I;" },
  1643. /* JNT0 60 */   { 0 , 0, 
  1644.         "26;[1=].Q.ff00&-.8I;" },
  1645. /* JNT1 61 */   { 0 , 0, 
  1646.         "46;[1=].Q.ff00&-.8I;" },
  1647. /* JNZ 62 */   { 0 , 0, 
  1648.         "96;[1=].Q.ff00&-.8I;" },
  1649. /* JOBF 63 */   { INST41 , INST41, 
  1650.         "86;[1=].Q.ff00&-.8I;" },
  1651. /* JT0 64 */   { 0 , 0, 
  1652.         "36;[1=].Q.ff00&-.8I;" },
  1653. /* JT1 65 */   { 0 , 0, 
  1654.         "56;[1=].Q.ff00&-.8I;" },
  1655. /* JTF 66 */   { 0 , 0, 
  1656.         "16;[1=].Q.ff00&-.8I;" },
  1657. /* JZ 67 */   { 0 , 0, 
  1658.         "c6;[1=].Q.ff00&-.8I;" },
  1659. /* MOV 68 */   { AFSELMASK , AFSELA, 
  1660.         "23;[1=];" },
  1661. /* MOV 69 */   { AFSELMASK , AFSELA, 
  1662.         "f0.[1#]|;" },
  1663. /* MOV 70 */   { AFSELMASK|MSELMASK , AFSELA|MSELPSW, 
  1664.         "c7;" },
  1665. /* MOV 71 */   { AFSELMASK|MSELMASK , AFSELA|MSELT, 
  1666.         "42;" },
  1667. /* MOV 72 */   { AFSELMASK , AFSELA, 
  1668.         "f8.[1#]|;" },
  1669. /* MOV 73 */   { AFSELMASK , AFSELA, 
  1670.         "a0.[1#]|;" },
  1671. /* MOV 74 */   { 0 , 0, 
  1672.         "b0.[1#]|;[2=];" },
  1673. /* MOV 75 */   { AFSELMASK|MSELMASK , AFSELA|MSELPSW, 
  1674.         "d7;" },
  1675. /* MOV 76 */   { INST41|AFSELMASK|MSELMASK , AFSELA|MSELSTS|INST41, 
  1676.         "50;" },
  1677. /* MOV 77 */   { AFSELMASK|MSELMASK , AFSELA|MSELT, 
  1678.         "62;" },
  1679. /* MOV 78 */   { AFSELMASK , AFSELA, 
  1680.         "a8.[1#]|;" },
  1681. /* MOV 79 */   { 0 , 0, 
  1682.         "b8.[1#]|;[2=];" },
  1683. /* MOVD 80 */   { AFSELMASK , AFSELA, 
  1684.         "3c.[1#]|;" },
  1685. /* MOVD 81 */   { AFSELMASK , AFSELA, 
  1686.         "0c.[1#]|;" },
  1687. /* MOVP3 82 */   { AFSELMASK , AFSELA, 
  1688.         "e3;" },
  1689. /* MOVP 83 */   { AFSELMASK , AFSELA, 
  1690.         "a3;" },
  1691. /* MOVX 84 */   { INSTNOT41|AFSELMASK , AFSELA|INSTNOT41, 
  1692.         "80.[1#]|;" },
  1693. /* MOVX 85 */   { INSTNOT41|AFSELMASK , AFSELA|INSTNOT41, 
  1694.         "90.[1#]|;" },
  1695. /* NOP 86 */   { 0 , 0, 
  1696.         "00;" },
  1697. /* ORL 87 */   { AFSELMASK , AFSELA, 
  1698.         "43;[1=];" },
  1699. /* ORL 88 */   { AFSELMASK , AFSELA, 
  1700.         "40.[1#]|;" },
  1701. /* ORL 89 */   { AFSELMASK , AFSELA, 
  1702.         "48.[1#]|;" },
  1703. /* ORL 90 */   { INSTNOT41|PSELMASK , PSELBUS|INSTNOT41, 
  1704.         "88;[1=];" },
  1705. /* ORL 91 */   { PSELMASK , PSELP1, 
  1706.         "89;[1=];" },
  1707. /* ORL 92 */   { PSELMASK , PSELP2, 
  1708.         "8a;[1=];" },
  1709. /* ORLD 93 */   { AFSELMASK , AFSELA, 
  1710.         "8c.[1#]|;" },
  1711. /* OUT 94 */   { INST41|AFSELMASK|PSELMASK , AFSELA|PSELDBB|INST41, 
  1712.         "02;" },
  1713. /* OUTL 95 */   { INSTNOT41|AFSELMASK|PSELMASK , AFSELA|PSELBUS|INSTNOT41, 
  1714.         "02;" },
  1715. /* OUTL 96 */   { AFSELMASK|PSELMASK , AFSELA|PSELP1, 
  1716.         "39;" },
  1717. /* OUTL 97 */   { AFSELMASK|PSELMASK , AFSELA|PSELP2, 
  1718.         "3a;" },
  1719. /* RET 98 */   { 0 , 0, 
  1720.         "83;" },
  1721. /* RETR 99 */   { 0 , 0, 
  1722.         "93;" },
  1723. /* RL 100 */   { AFSELMASK , AFSELA, 
  1724.         "e7;" },
  1725. /* RLC 101 */   { AFSELMASK , AFSELA, 
  1726.         "f7;" },
  1727. /* RR 102 */   { AFSELMASK , AFSELA, 
  1728.         "77;" },
  1729. /* RRC 103 */   { AFSELMASK , AFSELA, 
  1730.         "67;" },
  1731. /* SEL 104 */   { INSTNOT41 , INSTNOT41, 
  1732.         "c5.[1#]|;" },
  1733. /* SEL 105 */   { 0 , 0, 
  1734.         "c5.[1#]|;" },
  1735. /* STOP 106 */   { MSELMASK , MSELTCNT, 
  1736.         "65;" },
  1737. /* STRT 107 */   { MSELMASK , MSELCNT, 
  1738.         "45;" },
  1739. /* STRT 108 */   { MSELMASK , MSELT, 
  1740.         "55;" },
  1741. /* SWAP 109 */   { AFSELMASK , AFSELA, 
  1742.         "47;" },
  1743. /* XCH 110 */   { AFSELMASK , AFSELA, 
  1744.         "20.[1#]|;" },
  1745. /* XCH 111 */   { AFSELMASK , AFSELA, 
  1746.         "28.[1#]|;" },
  1747. /* XCHD 112 */   { AFSELMASK , AFSELA, 
  1748.         "30.[1#]|;" },
  1749. /* XRL 113 */   { AFSELMASK , AFSELA, 
  1750.         "d3;[1=];" },
  1751. /* XRL 114 */   { AFSELMASK , AFSELA, 
  1752.         "d0.[1#]|;" },
  1753. /* XRL 115 */   { AFSELMASK , AFSELA, 
  1754.         "d8.[1#]|;" },
  1755.     { 0,0,""} };
  1756. /* end fraptabdef.c */
  1757.